// Copyright (C) 2018-2025 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//

#include "openvino/op/convert_like.hpp"

#include <gtest/gtest.h>

#include <tuple>

#include "conversion.hpp"

using namespace ov;

namespace reference_tests {
namespace ConversionOpsRefTestDefinitions {
namespace {

const auto f4e2m1_values = std::vector<uint8_t>{0x0a, 0x2f, 0x49, 0x3b, 0x78, 0x05};
const auto e8m0_min = std::numeric_limits<float8_e8m0>::min();   // 2^-127
const auto f32_min = std::numeric_limits<float>::min() / 2;      // 2^-127
const auto f16_min = ov::float16::from_bits(0x1);                // smallest greater than zero = 2^-25
const auto bf16_min = std::numeric_limits<bfloat16>::min() / 2;  // 2^-127

INSTANTIATE_TEST_SUITE_P(
    smoke_Conversion_With_Hardcoded_Refs,
    ReferenceConversionLayerTest,
    ::testing::Values(
        // destination boolean
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u2,
                      ov::element::boolean,
                      std::vector<uint8_t>{0b10010011},
                      std::vector<char>{1, 0, 1, 1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u3,
                      ov::element::boolean,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<char>{0, 1, 0, 1, 0, 0, 0, 1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u6,
                      ov::element::boolean,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<char>{1, 1, 0, 1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 3},
                      ov::element::u8,
                      ov::element::boolean,
                      std::vector<uint8_t>{0,
                                           12,
                                           23,
                                           0,
                                           std::numeric_limits<uint8_t>::lowest(),
                                           std::numeric_limits<uint8_t>::max()},
                      std::vector<char>{0, 1, 1, 0, 0, 1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 3},
                      ov::element::i32,
                      ov::element::boolean,
                      std::vector<int32_t>{0,
                                           -12,
                                           23,
                                           0,
                                           std::numeric_limits<int32_t>::lowest(),
                                           std::numeric_limits<int32_t>::max()},
                      std::vector<char>{0, 1, 1, 0, 1, 1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{3, 3},
                      ov::element::f32,
                      ov::element::boolean,
                      std::vector<float>{0.f,
                                         1.5745f,
                                         0.12352f,
                                         0.f,
                                         std::numeric_limits<float>::lowest(),
                                         std::numeric_limits<float>::max(),
                                         std::numeric_limits<float>::min(),
                                         std::numeric_limits<float>::infinity(),
                                         -std::numeric_limits<float>::infinity()},
                      std::vector<char>{0, 1, 1, 0, 1, 1, 1, 1, 1}),
        // destination bf16
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u2,
                      ov::element::bf16,
                      std::vector<uint8_t>{0b10010011},
                      std::vector<bfloat16>{3.0f, 0.0f, 1.0f, 2.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u3,
                      ov::element::bf16,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<bfloat16>{0.0f, 2.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 3.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u6,
                      ov::element::bf16,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<bfloat16>{2.0f, 1.0f, 0.0f, 3.0f}),
        ConvertParams(
            ConversionTypes::CONVERT_LIKE,
            ov::PartialShape{1, 1, 3, 5},
            ov::element::f32,
            ov::element::bf16,
            std::
                vector<float>{0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f},
            std::vector<
                bfloat16>{0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{11},
                      ov::element::u8,
                      ov::element::bf16,
                      std::vector<uint8_t>{0, 10, 15, 20, 43, 56, 78, 99, 102, 130, 142},
                      std::vector<bfloat16>{0, 10, 15, 20, 43, 56, 78, 99, 102, 130, 142}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{11},
                      ov::element::f4e2m1,
                      ov::element::bf16,
                      // Unpacked data only first nibble got value, the other is 0
                      std::vector<float4_e2m1>{0.0f, -1.0f, -0.5f, 6.0f, -4.0f, 1.5f},
                      std::vector<bfloat16>{0.0f, 0.0f, -1.0f, 0.0f, -0.5f, 0.0f, 6.0f, 0.0f, -4.0f, 0.0f, 1.5f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{6},
                      ov::element::f8e8m0,
                      ov::element::bf16,
                      std::vector<float8_e8m0>{0.0f, 1.0f, 0.5f, 6.0f, 4.0f, 1.5f},
                      std::vector<bfloat16>{bf16_min, 1.0f, 0.5f, 8.0f, 4.0f, 2.f}),

        // destination f16
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u2,
                      ov::element::f16,
                      std::vector<uint8_t>{0b10010011},
                      std::vector<float16>{3.0f, 0.0f, 1.0f, 2.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u3,
                      ov::element::f16,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<float16>{0.0f, 2.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 3.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u6,
                      ov::element::f16,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<float16>{2.0f, 1.0f, 0.0f, 3.0f}),
        ConvertParams(
            ConversionTypes::CONVERT_LIKE,
            ov::PartialShape{1, 1, 3, 5},
            ov::element::f32,
            ov::element::f16,
            std::
                vector<float>{0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f},
            std::vector<
                float16>{0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{11},
                      ov::element::u8,
                      ov::element::f16,
                      std::vector<uint8_t>{0, 10, 15, 20, 43, 56, 78, 99, 102, 130, 142},
                      std::vector<float16>{0, 10, 15, 20, 43, 56, 78, 99, 102, 130, 142}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::nf4,
                      ov::element::f16,
                      std::vector<uint8_t>{0xE1, 0x1F},
                      std::vector<float16>{-0.6961928009986877f, 0.7229568362236023f, 1.0f, -0.6961928009986877f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{11},
                      ov::element::f4e2m1,
                      ov::element::f16,
                      f4e2m1_values,
                      std::vector<float16>{-1.0f, 0.0f, -6.0f, 1.0f, -0.5f, 2.0f, -1.5f, 1.5f, -0.0f, 6.0f, 3.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::f8e8m0,
                      ov::element::f16,
                      std::vector<float8_e8m0>{-0.0f, -6.0f, 1.0f, 0.5f, 2.0f, 1.5f, 6.0f, 3.0f},
                      std::vector<float16>{f16_min, f16_min, 1.0f, 0.5f, 2.0f, 2.0f, 8.0f, 2.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{7},
                      ov::element::bf16,
                      ov::element::f16,
                      std::vector<bfloat16>{0.5f, 0.1640625f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f},
                      std::vector<float16>{0.5f, 0.1640625f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f}),
        // destination f32
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 2},
                      ov::element::u1,
                      ov::element::f32,
                      std::vector<uint8_t>{0xA0},
                      std::vector<float>{1.0f, 0.0f, 1.0f, 0.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u2,
                      ov::element::f32,
                      std::vector<uint8_t>{0b10010011},
                      std::vector<float>{3.0f, 0.0f, 1.0f, 2.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u3,
                      ov::element::f32,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<float>{0.0f, 2.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 3.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 2},
                      ov::element::u4,
                      ov::element::f32,
                      std::vector<uint8_t>{0xBF, 0xA0},
                      std::vector<float>{15.0f, 11.0f, 0.0f, 10.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u6,
                      ov::element::f32,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<float>{2.0f, 1.0f, 0.0f, 3.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 2},
                      ov::element::u8,
                      ov::element::f32,
                      std::vector<uint8_t>{255, 128, 32, 0},
                      std::vector<float>{255.0f, 128.0f, 32.0f, 0.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 2},
                      ov::element::u16,
                      ov::element::f32,
                      std::vector<uint16_t>{64000, 32000, 128, 0},
                      std::vector<float>{64000.0f, 32000.0f, 128.0f, 0.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 2},
                      ov::element::u32,
                      ov::element::f32,
                      std::vector<uint32_t>{4000000, 2000000, 128, 0},
                      std::vector<float>{4000000.0f, 2000000.0f, 128.0f, 0.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 2},
                      ov::element::u64,
                      ov::element::f32,
                      std::vector<uint64_t>{4000000, 2000000, 128, 0},
                      std::vector<float>{4000000.0f, 2000000.0f, 128.0f, 0.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 2},
                      ov::element::i4,
                      ov::element::f32,
                      std::vector<uint8_t>{0xEF, 0x2F},
                      std::vector<float>{-1.0f, -2.0f, -1.0f, 2.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 2},
                      ov::element::i8,
                      ov::element::f32,
                      std::vector<int8_t>{-127, -0, 0, 127},
                      std::vector<float>{-127.0f, -0.0f, 0.0f, 127.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 2},
                      ov::element::i16,
                      ov::element::f32,
                      std::vector<int16_t>{-32000, -0, 0, 32000},
                      std::vector<float>{-32000.0f, -0.0f, 0.0f, 32000.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 2},
                      ov::element::i32,
                      ov::element::f32,
                      std::vector<int32_t>{-64000, -0, 0, 64000},
                      std::vector<float>{-64000.0f, -0.0f, 0.0f, 64000.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 2},
                      ov::element::i64,
                      ov::element::f32,
                      std::vector<int64_t>{-64000, -0, 0, 64000},
                      std::vector<float>{-64000.0f, -0.0f, 0.0f, 64000.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{1, 1, 3, 5},
                      ov::element::bf16,
                      ov::element::f32,
                      std::vector<bfloat16>{0.5f,
                                            1.5f,
                                            0.5f,
                                            2.5f,
                                            1.5f,
                                            0.5f,
                                            3.5f,
                                            2.5f,
                                            0.5f,
                                            0.5f,
                                            2.5f,
                                            0.5f,
                                            0.5f,
                                            0.5f,
                                            1.5f},
                      std::vector<float>{0.5f,
                                         1.5f,
                                         0.5f,
                                         2.5f,
                                         1.5f,
                                         0.5f,
                                         3.5f,
                                         2.5f,
                                         0.5f,
                                         0.5f,
                                         2.5f,
                                         0.5f,
                                         0.5f,
                                         0.5f,
                                         1.5f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{1, 1, 3, 5},
                      ov::element::f16,
                      ov::element::f32,
                      std::vector<float16>{0.5f,
                                           1.5f,
                                           0.5f,
                                           2.5f,
                                           1.5f,
                                           0.5f,
                                           3.5f,
                                           2.5f,
                                           0.5f,
                                           0.5f,
                                           2.5f,
                                           0.5f,
                                           0.5f,
                                           0.5f,
                                           1.5f},
                      std::vector<float>{0.5f,
                                         1.5f,
                                         0.5f,
                                         2.5f,
                                         1.5f,
                                         0.5f,
                                         3.5f,
                                         2.5f,
                                         0.5f,
                                         0.5f,
                                         2.5f,
                                         0.5f,
                                         0.5f,
                                         0.5f,
                                         1.5f}),
        ConvertParams(
            ConversionTypes::CONVERT_LIKE,
            ov::PartialShape{1, 1, 3, 5},
            ov::element::f32,
            ov::element::f32,
            std::
                vector<float>{0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f},
            std::vector<
                float>{0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{11},
                      ov::element::f4e2m1,
                      ov::element::f32,
                      // only one nibble got value others are be 0
                      f4e2m1_values,
                      std::vector<float>{-1.0f, 0.0f, -6.0f, 1.0f, -0.5f, 2.0f, -1.5f, 1.5f, -0.0f, 6.0f, 3.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{10},
                      ov::element::f8e8m0,
                      ov::element::f32,
                      std::vector<float8_e8m0>{-1.0f, -0.0f, 0.6f, 1.0f, 0.5f, 2.0f, 1.5f, 2.5f, 6.0f, 3.0f},
                      std::vector<float>{f32_min, f32_min, 0.5f, 1.0f, 0.5f, 2.0f, 2.0f, 2.0f, 8.0f, 2.0f}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::nf4,
                      ov::element::f32,
                      std::vector<uint8_t>{0xE1, 0x1F},
                      std::vector<float>{-0.6961928009986877f, 0.7229568362236023f, 1.0f, -0.6961928009986877f}),
        // destination i4
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u1,
                      ov::element::i4,
                      std::vector<uint8_t>{0xA0},
                      std::vector<uint8_t>{0x01, 0x01}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u2,
                      ov::element::i4,
                      std::vector<uint8_t>{0b10010011},
                      std::vector<uint8_t>{0x03, 0x21}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u3,
                      ov::element::i4,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<uint8_t>{0x20, 0x10, 0x00, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u4,
                      ov::element::i4,
                      std::vector<uint8_t>{0x12, 0x03},
                      std::vector<uint8_t>{0x12, 0x03}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u6,
                      ov::element::i4,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<uint8_t>{0x12, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u8,
                      ov::element::i4,
                      std::vector<uint8_t>{1, 2, 0, 3},
                      std::vector<uint8_t>{0x21, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u16,
                      ov::element::i4,
                      std::vector<uint16_t>{1, 2, 0, 3},
                      std::vector<uint8_t>{0x21, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u32,
                      ov::element::i4,
                      std::vector<uint32_t>{1, 2, 0, 3},
                      std::vector<uint8_t>{0x21, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u64,
                      ov::element::i4,
                      std::vector<uint64_t>{1, 2, 0, 3},
                      std::vector<uint8_t>{0x21, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i4,
                      ov::element::i4,
                      std::vector<uint8_t>{0xFE, 0x03},
                      std::vector<uint8_t>{0xFE, 0x03}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i8,
                      ov::element::i4,
                      std::vector<int8_t>{-1, -2, 2, 3},
                      std::vector<uint8_t>{0xEF, 0x32}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i16,
                      ov::element::i4,
                      std::vector<int16_t>{-1, -2, 2, 3},
                      std::vector<uint8_t>{0xEF, 0x32}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i32,
                      ov::element::i4,
                      std::vector<int32_t>{-1, -2, 2, 3},
                      std::vector<uint8_t>{0xEF, 0x32}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i64,
                      ov::element::i4,
                      std::vector<int64_t>{-1, -2, 2, 3},
                      std::vector<uint8_t>{0xEF, 0x32}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f16,
                      ov::element::i4,
                      std::vector<ov::float16>{-1, -2, 0, 3},
                      std::vector<uint8_t>{0xEF, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::bf16,
                      ov::element::i4,
                      std::vector<ov::bfloat16>{-1, -2, 0, 3},
                      std::vector<uint8_t>{0xEF, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f32,
                      ov::element::i4,
                      std::vector<float>{-1, -2, 2, 3},
                      std::vector<uint8_t>{0xEF, 0x32}),
        // destination i8
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u1,
                      ov::element::i8,
                      std::vector<uint8_t>{0x81},
                      std::vector<int8_t>{1, 0, 0, 0, 0, 0, 0, 1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u2,
                      ov::element::i8,
                      std::vector<uint8_t>{0b10010011},
                      std::vector<int8_t>{3, 0, 1, 2}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u3,
                      ov::element::i8,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<int8_t>{0, 2, 0, 1, 0, 0, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u4,
                      ov::element::i8,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<int8_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u6,
                      ov::element::i8,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<int8_t>{2, 1, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u8,
                      ov::element::i8,
                      std::vector<uint8_t>{1, 2, 0, 3},
                      std::vector<int8_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u16,
                      ov::element::i8,
                      std::vector<uint16_t>{1, 2, 0, 3},
                      std::vector<int8_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u32,
                      ov::element::i8,
                      std::vector<uint32_t>{1, 2, 0, 3},
                      std::vector<int8_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u64,
                      ov::element::i8,
                      std::vector<uint64_t>{1, 2, 0, 3},
                      std::vector<int8_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i4,
                      ov::element::i8,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<int8_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i8,
                      ov::element::i8,
                      std::vector<int8_t>{-1, -2, 2, 3},
                      std::vector<int8_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i16,
                      ov::element::i8,
                      std::vector<int16_t>{-1, -2, 2, 3},
                      std::vector<int8_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i32,
                      ov::element::i8,
                      std::vector<int32_t>{-1, -2, 2, 3},
                      std::vector<int8_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i64,
                      ov::element::i8,
                      std::vector<int64_t>{-1, -2, 2, 3},
                      std::vector<int8_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f16,
                      ov::element::i8,
                      std::vector<ov::float16>{-1, -2, 0, 3},
                      std::vector<int8_t>{-1, -2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::bf16,
                      ov::element::i8,
                      std::vector<ov::bfloat16>{-1, -2, 0, 3},
                      std::vector<int8_t>{-1, -2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f32,
                      ov::element::i8,
                      std::vector<float>{-1, -2, 2.2, 3.8},
                      std::vector<int8_t>{-1, -2, 2, 3}),
        // destination i16
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u1,
                      ov::element::i16,
                      std::vector<uint8_t>{0x81},
                      std::vector<int16_t>{1, 0, 0, 0, 0, 0, 0, 1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u2,
                      ov::element::i16,
                      std::vector<uint8_t>{0b10010011},
                      std::vector<int16_t>{3, 0, 1, 2}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u3,
                      ov::element::i16,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<int16_t>{0, 2, 0, 1, 0, 0, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u4,
                      ov::element::i16,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<int16_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u6,
                      ov::element::i16,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<int16_t>{2, 1, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u8,
                      ov::element::i16,
                      std::vector<uint8_t>{1, 2, 0, 3},
                      std::vector<int16_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u16,
                      ov::element::i16,
                      std::vector<uint16_t>{1, 2, 0, 3},
                      std::vector<int16_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u32,
                      ov::element::i16,
                      std::vector<uint32_t>{1, 2, 0, 3},
                      std::vector<int16_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u64,
                      ov::element::i16,
                      std::vector<uint64_t>{1, 2, 0, 3},
                      std::vector<int16_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i4,
                      ov::element::i16,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<int16_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i8,
                      ov::element::i16,
                      std::vector<int8_t>{-1, -2, 2, 3},
                      std::vector<int16_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i16,
                      ov::element::i16,
                      std::vector<int16_t>{-1, -2, 2, 3},
                      std::vector<int16_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i32,
                      ov::element::i16,
                      std::vector<int32_t>{-1, -2, 2, 3},
                      std::vector<int16_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i64,
                      ov::element::i16,
                      std::vector<int64_t>{-1, -2, 2, 3},
                      std::vector<int16_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f16,
                      ov::element::i16,
                      std::vector<ov::float16>{-1, -2, 0, 3},
                      std::vector<int16_t>{-1, -2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::bf16,
                      ov::element::i16,
                      std::vector<ov::bfloat16>{-1, -2, 0, 3},
                      std::vector<int16_t>{-1, -2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f32,
                      ov::element::i16,
                      std::vector<float>{-1, -2, 2.2, 3.8},
                      std::vector<int16_t>{-1, -2, 2, 3}),
        // destination i32
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u1,
                      ov::element::i32,
                      std::vector<uint8_t>{0x81},
                      std::vector<int32_t>{1, 0, 0, 0, 0, 0, 0, 1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u2,
                      ov::element::i32,
                      std::vector<uint8_t>{0b10010011},
                      std::vector<int32_t>{3, 0, 1, 2}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u3,
                      ov::element::i32,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<int32_t>{0, 2, 0, 1, 0, 0, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u4,
                      ov::element::i32,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<int32_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u6,
                      ov::element::i32,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<int32_t>{2, 1, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u8,
                      ov::element::i32,
                      std::vector<uint8_t>{1, 2, 0, 3},
                      std::vector<int32_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u16,
                      ov::element::i32,
                      std::vector<uint16_t>{1, 2, 0, 3},
                      std::vector<int32_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u32,
                      ov::element::i32,
                      std::vector<uint32_t>{1, 2, 0, 3},
                      std::vector<int32_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u64,
                      ov::element::i32,
                      std::vector<uint64_t>{1, 2, 0, 3},
                      std::vector<int32_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i4,
                      ov::element::i32,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<int32_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i8,
                      ov::element::i32,
                      std::vector<int8_t>{-1, -2, 2, 3},
                      std::vector<int32_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i16,
                      ov::element::i32,
                      std::vector<int16_t>{-1, -2, 2, 3},
                      std::vector<int32_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i32,
                      ov::element::i32,
                      std::vector<int32_t>{-1, -2, 2, 3},
                      std::vector<int32_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i64,
                      ov::element::i32,
                      std::vector<int64_t>{-1, -2, 2, 3},
                      std::vector<int32_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f16,
                      ov::element::i32,
                      std::vector<ov::float16>{-1, -2, 0, 3},
                      std::vector<int32_t>{-1, -2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::bf16,
                      ov::element::i32,
                      std::vector<ov::bfloat16>{-1, -2, 0, 3},
                      std::vector<int32_t>{-1, -2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f32,
                      ov::element::i32,
                      std::vector<float>{-1, -2, 2.2, 3.8},
                      std::vector<int32_t>{-1, -2, 2, 3}),
        // destination i64
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u1,
                      ov::element::i64,
                      std::vector<uint8_t>{0x81},
                      std::vector<int64_t>{1, 0, 0, 0, 0, 0, 0, 1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u2,
                      ov::element::i64,
                      std::vector<uint8_t>{0b10010011},
                      std::vector<int64_t>{3, 0, 1, 2}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u3,
                      ov::element::i64,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<int64_t>{0, 2, 0, 1, 0, 0, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u4,
                      ov::element::i64,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<int64_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u6,
                      ov::element::i64,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<int64_t>{2, 1, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u8,
                      ov::element::i64,
                      std::vector<uint8_t>{1, 2, 0, 3},
                      std::vector<int64_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u16,
                      ov::element::i64,
                      std::vector<uint16_t>{1, 2, 0, 3},
                      std::vector<int64_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u32,
                      ov::element::i64,
                      std::vector<uint32_t>{1, 2, 0, 3},
                      std::vector<int64_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u64,
                      ov::element::i64,
                      std::vector<uint64_t>{1, 2, 0, 3},
                      std::vector<int64_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i4,
                      ov::element::i64,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<int64_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i8,
                      ov::element::i64,
                      std::vector<int8_t>{-1, -2, 2, 3},
                      std::vector<int64_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i16,
                      ov::element::i64,
                      std::vector<int16_t>{-1, -2, 2, 3},
                      std::vector<int64_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i32,
                      ov::element::i64,
                      std::vector<int32_t>{-1, -2, 2, 3},
                      std::vector<int64_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i64,
                      ov::element::i64,
                      std::vector<int64_t>{-1, -2, 2, 3},
                      std::vector<int64_t>{-1, -2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f16,
                      ov::element::i64,
                      std::vector<ov::float16>{-1, -2, 0, 3},
                      std::vector<int64_t>{-1, -2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::bf16,
                      ov::element::i64,
                      std::vector<ov::bfloat16>{-1, -2, 0, 3},
                      std::vector<int64_t>{-1, -2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f32,
                      ov::element::i64,
                      std::vector<float>{-1, -2, 2.2, 3.8},
                      std::vector<int64_t>{-1, -2, 2, 3}),

        // destination u1
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u1,
                      ov::element::u1,
                      std::vector<uint8_t>{0xA0},
                      std::vector<uint8_t>{0xA0}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u2,
                      ov::element::u1,
                      std::vector<uint8_t>{0b10010011, 0x00},
                      std::vector<uint8_t>{0b10100000}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u3,
                      ov::element::u1,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<uint8_t>{0b00010001}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u4,
                      ov::element::u1,
                      std::vector<uint8_t>{0x01, 0x10, 0x00, 0x00},
                      std::vector<uint8_t>{0x90}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u6,
                      ov::element::u1,
                      std::vector<uint8_t>{0x21, 0x03, 0x00, 0x00, 0x00, 0x00},
                      std::vector<uint8_t>{0b01010000}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u8,
                      ov::element::u1,
                      std::vector<uint8_t>{1, 0, 1, 0, 0, 0, 0, 1},
                      std::vector<uint8_t>{0xA1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u16,
                      ov::element::u1,
                      std::vector<uint16_t>{1, 0, 1, 0, 0, 0, 0, 1},
                      std::vector<uint8_t>{0xA1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u32,
                      ov::element::u1,
                      std::vector<uint32_t>{1, 0, 1, 0, 0, 0, 0, 1},
                      std::vector<uint8_t>{0xA1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u64,
                      ov::element::u1,
                      std::vector<uint64_t>{1, 0, 1, 0, 0, 0, 0, 1},
                      std::vector<uint8_t>{0xA1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::i4,
                      ov::element::u1,
                      std::vector<uint8_t>{0x01, 0x10, 0x00, 0x00},
                      std::vector<uint8_t>{0x90}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::i8,
                      ov::element::u1,
                      std::vector<int8_t>{1, 0, 1, 0, 0, 0, 0, 1},
                      std::vector<uint8_t>{0xA1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::i16,
                      ov::element::u1,
                      std::vector<int16_t>{1, 0, 1, 0, 0, 0, 0, 1},
                      std::vector<uint8_t>{0xA1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::i32,
                      ov::element::u1,
                      std::vector<int32_t>{1, 0, 1, 0, 0, 0, 0, 1},
                      std::vector<uint8_t>{0xA1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::i64,
                      ov::element::u1,
                      std::vector<int64_t>{1, 0, 1, 0, 0, 0, 0, 1},
                      std::vector<uint8_t>{0xA1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::f16,
                      ov::element::u1,
                      std::vector<ov::float16>{1, 0, 1, 0, 0, 0, 0, 1},
                      std::vector<uint8_t>{0xA1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::bf16,
                      ov::element::u1,
                      std::vector<ov::bfloat16>{1, 0, 1, 0, 0, 0, 0, 1},
                      std::vector<uint8_t>{0xA1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::f32,
                      ov::element::u1,
                      std::vector<float>{1, 0, 1, 0, 0, 0, 0, 1},
                      std::vector<uint8_t>{0xA1}),

        // destination u4
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u1,
                      ov::element::u4,
                      std::vector<uint8_t>{0xA0},
                      std::vector<uint8_t>{0x01, 0x01}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u2,
                      ov::element::u4,
                      std::vector<uint8_t>{0b10010011},
                      std::vector<uint8_t>{0x03, 0x21}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u3,
                      ov::element::u4,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<uint8_t>{0x20, 0x10, 0x00, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u4,
                      ov::element::u4,
                      std::vector<uint8_t>{0x12, 0x03},
                      std::vector<uint8_t>{0x12, 0x03}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u6,
                      ov::element::u4,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<uint8_t>{0x12, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u8,
                      ov::element::u4,
                      std::vector<uint8_t>{1, 2, 0, 3},
                      std::vector<uint8_t>{0x21, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u16,
                      ov::element::u4,
                      std::vector<uint16_t>{1, 2, 0, 3},
                      std::vector<uint8_t>{0x21, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u32,
                      ov::element::u4,
                      std::vector<uint32_t>{1, 2, 0, 3},
                      std::vector<uint8_t>{0x21, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u64,
                      ov::element::u4,
                      std::vector<uint64_t>{1, 2, 0, 3},
                      std::vector<uint8_t>{0x21, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i4,
                      ov::element::u4,
                      std::vector<uint8_t>{0xFE, 0x03},
                      std::vector<uint8_t>{0xFE, 0x03}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i8,
                      ov::element::u4,
                      std::vector<int8_t>{-1, -2, 2, 3},
                      std::vector<uint8_t>{0xEF, 0x32}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i16,
                      ov::element::u4,
                      std::vector<int16_t>{-1, -2, 2, 3},
                      std::vector<uint8_t>{0xEF, 0x32}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i32,
                      ov::element::u4,
                      std::vector<int32_t>{-1, -2, 2, 3},
                      std::vector<uint8_t>{0xEF, 0x32}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i64,
                      ov::element::u4,
                      std::vector<int64_t>{-1, -2, 2, 3},
                      std::vector<uint8_t>{0xEF, 0x32}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f16,
                      ov::element::u4,
                      std::vector<ov::float16>{-1, -2, 0, 3},
                      std::vector<uint8_t>{0xEF, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::bf16,
                      ov::element::u4,
                      std::vector<ov::bfloat16>{-1, -2, 0, 3},
                      std::vector<uint8_t>{0xEF, 0x30}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f32,
                      ov::element::u4,
                      std::vector<float>{-1, -2, 2, 3},
                      std::vector<uint8_t>{0xEF, 0x32}),

        // destination u8
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u1,
                      ov::element::u8,
                      std::vector<uint8_t>{0x81},
                      std::vector<uint8_t>{1, 0, 0, 0, 0, 0, 0, 1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u2,
                      ov::element::u8,
                      std::vector<uint8_t>{0b10010011},
                      std::vector<uint8_t>{3, 0, 1, 2}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u3,
                      ov::element::u8,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<uint8_t>{0, 2, 0, 1, 0, 0, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u4,
                      ov::element::u8,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<uint8_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u6,
                      ov::element::u8,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<uint8_t>{2, 1, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u8,
                      ov::element::u8,
                      std::vector<uint8_t>{1, 2, 0, 3},
                      std::vector<uint8_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u16,
                      ov::element::u8,
                      std::vector<uint16_t>{1, 2, 0, 3},
                      std::vector<uint8_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u32,
                      ov::element::u8,
                      std::vector<uint32_t>{1, 2, 0, 3},
                      std::vector<uint8_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u64,
                      ov::element::u8,
                      std::vector<uint64_t>{1, 2, 0, 3},
                      std::vector<uint8_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i4,
                      ov::element::u8,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<uint8_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i8,
                      ov::element::u8,
                      std::vector<int8_t>{1, 2, 2, 3},
                      std::vector<uint8_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i16,
                      ov::element::u8,
                      std::vector<int16_t>{1, 2, 2, 3},
                      std::vector<uint8_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i32,
                      ov::element::u8,
                      std::vector<int32_t>{1, 2, 2, 3},
                      std::vector<uint8_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i64,
                      ov::element::u8,
                      std::vector<int64_t>{1, 2, 2, 3},
                      std::vector<uint8_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f16,
                      ov::element::u8,
                      std::vector<ov::float16>{1, 2, 0, 3},
                      std::vector<uint8_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::bf16,
                      ov::element::u8,
                      std::vector<ov::bfloat16>{1, 2, 0, 3},
                      std::vector<uint8_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f32,
                      ov::element::u8,
                      std::vector<float>{1, 2, 2.2, 3.8},
                      std::vector<uint8_t>{1, 2, 2, 3}),

        // destination u16
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u1,
                      ov::element::u16,
                      std::vector<uint8_t>{0x81},
                      std::vector<uint16_t>{1, 0, 0, 0, 0, 0, 0, 1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u2,
                      ov::element::u16,
                      std::vector<uint8_t>{0b10010011},
                      std::vector<uint16_t>{3, 0, 1, 2}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u3,
                      ov::element::u16,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<uint16_t>{0, 2, 0, 1, 0, 0, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u4,
                      ov::element::u16,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<uint16_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u6,
                      ov::element::u16,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<uint16_t>{2, 1, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u8,
                      ov::element::u16,
                      std::vector<uint8_t>{1, 2, 0, 3},
                      std::vector<uint16_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u16,
                      ov::element::u16,
                      std::vector<uint16_t>{1, 2, 0, 3},
                      std::vector<uint16_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u32,
                      ov::element::u16,
                      std::vector<uint32_t>{1, 2, 0, 3},
                      std::vector<uint16_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u64,
                      ov::element::u16,
                      std::vector<uint64_t>{1, 2, 0, 3},
                      std::vector<uint16_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i4,
                      ov::element::u16,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<uint16_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i8,
                      ov::element::u16,
                      std::vector<int8_t>{1, 2, 2, 3},
                      std::vector<uint16_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i16,
                      ov::element::u16,
                      std::vector<int16_t>{1, 2, 2, 3},
                      std::vector<uint16_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i32,
                      ov::element::u16,
                      std::vector<int32_t>{1, 2, 2, 3},
                      std::vector<uint16_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i64,
                      ov::element::u16,
                      std::vector<int64_t>{1, 2, 2, 3},
                      std::vector<uint16_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f16,
                      ov::element::u16,
                      std::vector<ov::float16>{1, 2, 0, 3},
                      std::vector<uint16_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::bf16,
                      ov::element::u16,
                      std::vector<ov::bfloat16>{1, 2, 0, 3},
                      std::vector<uint16_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f32,
                      ov::element::u16,
                      std::vector<float>{1, 2, 2.2, 3.8},
                      std::vector<uint16_t>{1, 2, 2, 3}),

        // destination u32
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u1,
                      ov::element::u32,
                      std::vector<uint8_t>{0x81},
                      std::vector<uint32_t>{1, 0, 0, 0, 0, 0, 0, 1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u2,
                      ov::element::u32,
                      std::vector<uint8_t>{0b10010011},
                      std::vector<uint32_t>{3, 0, 1, 2}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u3,
                      ov::element::u32,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<uint32_t>{0, 2, 0, 1, 0, 0, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u4,
                      ov::element::u32,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<uint32_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u6,
                      ov::element::u32,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<uint32_t>{2, 1, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u8,
                      ov::element::u32,
                      std::vector<uint8_t>{1, 2, 0, 3},
                      std::vector<uint32_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u16,
                      ov::element::u32,
                      std::vector<uint16_t>{1, 2, 0, 3},
                      std::vector<uint32_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u32,
                      ov::element::u32,
                      std::vector<uint32_t>{1, 2, 0, 3},
                      std::vector<uint32_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u64,
                      ov::element::u32,
                      std::vector<uint64_t>{1, 2, 0, 3},
                      std::vector<uint32_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i4,
                      ov::element::u32,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<uint32_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i8,
                      ov::element::u32,
                      std::vector<int8_t>{1, 2, 2, 3},
                      std::vector<uint32_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i16,
                      ov::element::u32,
                      std::vector<int16_t>{1, 2, 2, 3},
                      std::vector<uint32_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i32,
                      ov::element::u32,
                      std::vector<int32_t>{1, 2, 2, 3},
                      std::vector<uint32_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i64,
                      ov::element::u32,
                      std::vector<int64_t>{1, 2, 2, 3},
                      std::vector<uint32_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f16,
                      ov::element::u32,
                      std::vector<ov::float16>{1, 2, 0, 3},
                      std::vector<uint32_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::bf16,
                      ov::element::u32,
                      std::vector<ov::bfloat16>{1, 2, 0, 3},
                      std::vector<uint32_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f32,
                      ov::element::u32,
                      std::vector<float>{1, 2, 2.2, 3.8},
                      std::vector<uint32_t>{1, 2, 2, 3}),
        // destination u64
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u1,
                      ov::element::u64,
                      std::vector<uint8_t>{0x81},
                      std::vector<uint64_t>{1, 0, 0, 0, 0, 0, 0, 1}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u2,
                      ov::element::u64,
                      std::vector<uint8_t>{0b10010011},
                      std::vector<uint64_t>{3, 0, 1, 2}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{8},
                      ov::element::u3,
                      ov::element::u64,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<uint64_t>{0, 2, 0, 1, 0, 0, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u4,
                      ov::element::u64,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<uint64_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u6,
                      ov::element::u64,
                      std::vector<uint8_t>{0x21, 0x03, 0x00},
                      std::vector<uint64_t>{2, 1, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u8,
                      ov::element::u64,
                      std::vector<uint8_t>{1, 2, 0, 3},
                      std::vector<uint64_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u16,
                      ov::element::u64,
                      std::vector<uint16_t>{1, 2, 0, 3},
                      std::vector<uint64_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u32,
                      ov::element::u64,
                      std::vector<uint32_t>{1, 2, 0, 3},
                      std::vector<uint64_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::u64,
                      ov::element::u64,
                      std::vector<uint64_t>{1, 2, 0, 3},
                      std::vector<uint64_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i4,
                      ov::element::u64,
                      std::vector<uint8_t>{0x12, 0x34},
                      std::vector<uint64_t>{2, 1, 4, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i8,
                      ov::element::u64,
                      std::vector<int8_t>{1, 2, 2, 3},
                      std::vector<uint64_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i16,
                      ov::element::u64,
                      std::vector<int16_t>{1, 2, 2, 3},
                      std::vector<uint64_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i32,
                      ov::element::u64,
                      std::vector<int32_t>{1, 2, 2, 3},
                      std::vector<uint64_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::i64,
                      ov::element::u64,
                      std::vector<int64_t>{1, 2, 2, 3},
                      std::vector<uint64_t>{1, 2, 2, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f16,
                      ov::element::u64,
                      std::vector<ov::float16>{1, 2, 0, 3},
                      std::vector<uint64_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::bf16,
                      ov::element::u64,
                      std::vector<ov::bfloat16>{1, 2, 0, 3},
                      std::vector<uint64_t>{1, 2, 0, 3}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f32,
                      ov::element::u64,
                      std::vector<float>{1, 2, 2.2, 3.8},
                      std::vector<uint64_t>{1, 2, 2, 3}),
        // destination nf4 (use quantization)
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::f16,
                      ov::element::nf4,
                      std::vector<float16>{-0.6961928009986877f, 0.7229568362236023f, 1.0f, -0.5250730514526367f},
                      std::vector<uint8_t>{0xE1, 0x2F}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{4},
                      ov::element::nf4,
                      ov::element::nf4,
                      std::vector<uint8_t>{0xE1, 0x2f},
                      std::vector<uint8_t>{0xE1, 0x2F}),
        // destination u2
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::boolean,
                      ov::element::u2,
                      std::vector<char>{1, 0, 1, 1, 0, 1, 0, 0},
                      std::vector<uint8_t>{0b01010001, 0b00000100}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u1,
                      ov::element::u2,
                      std::vector<uint8_t>{0b11001011},
                      std::vector<uint8_t>{0x05, 0x51}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{1, 8},
                      ov::element::u3,
                      ov::element::u2,
                      std::vector<uint8_t>{0b00100111, 0b00011010, 0b00001000},
                      std::vector<uint8_t>{0b11011000, 0b10100100}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u4,
                      ov::element::u2,
                      std::vector<uint8_t>{0x21, 0x01, 0x31, 0xff},
                      std::vector<uint8_t>{0b00011001, 0b11111101}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{1, 8},
                      ov::element::u6,
                      ov::element::u2,
                      std::vector<uint8_t>{0x02, 0x13, 0x00, 0x81, 0x04, 0b01001011},
                      std::vector<uint8_t>{0b11011000, 0b00000100}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u8,
                      ov::element::u2,
                      std::vector<uint8_t>{0, 2, 1, 3, 4, 1, 2, 2},
                      std::vector<uint8_t>{0b11011000, 0b10100100}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u16,
                      ov::element::u2,
                      std::vector<uint16_t>{0, 2, 1, 3, 4, 1, 2, 2},
                      std::vector<uint8_t>{0b11011000, 0b10100100}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u32,
                      ov::element::u2,
                      std::vector<uint32_t>{0, 2, 1, 3, 4, 1, 2, 2},
                      std::vector<uint8_t>{0b11011000, 0b10100100}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u64,
                      ov::element::u2,
                      std::vector<uint64_t>{0, 2, 1, 3, 4, 1, 2, 2},
                      std::vector<uint8_t>{0b11011000, 0b10100100}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::i4,
                      ov::element::u2,
                      std::vector<uint8_t>{0x21, 0x01, 0x31, 0xff},
                      std::vector<uint8_t>{0b00011001, 0b11111101}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::i8,
                      ov::element::u2,
                      std::vector<int8_t>{0, 2, 1, 3, 4, 1, 2, 2},
                      std::vector<uint8_t>{0b11011000, 0b10100100}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::i16,
                      ov::element::u2,
                      std::vector<int16_t>{0, 2, 1, 3, 4, 1, 2, 2},
                      std::vector<uint8_t>{0b11011000, 0b10100100}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::i32,
                      ov::element::u2,
                      std::vector<int32_t>{0, 2, 1, 3, 4, 1, 2, 2},
                      std::vector<uint8_t>{0b11011000, 0b10100100}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::i64,
                      ov::element::u2,
                      std::vector<int64_t>{0, 2, 1, 3, 4, 1, 2, 2},
                      std::vector<uint8_t>{0b11011000, 0b10100100}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{1, 8},
                      ov::element::f8e4m3,
                      ov::element::u2,
                      std::vector<float8_e4m3>{0.1f, 2.0f, 1.1f, 3.0f, 4.0f, 1.0f, 2.2f, 2.8f},
                      std::vector<uint8_t>{0b11011000, 0b10100100}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::f16,
                      ov::element::u2,
                      std::vector<float16>{0.1f, 2.0f, 1.1f, 3.0f, 4.0f, 1.0f, 2.2f, 2.8f},
                      std::vector<uint8_t>{0b11011000, 0b10100100}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::f32,
                      ov::element::u2,
                      std::vector<float>{0.1f, 2.0f, 1.1f, 3.0f, 4.0f, 1.0f, 2.2f, 2.8f},
                      std::vector<uint8_t>{0b11011000, 0b10100100}),
        // destination u3
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::boolean,
                      ov::element::u3,
                      std::vector<char>{1, 0, 1, 1, 0, 1, 0, 0},
                      std::vector<uint8_t>{0b01000101, 0b00010000, 0x00}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u1,
                      ov::element::u3,
                      std::vector<uint8_t>{0b11001011},
                      std::vector<uint8_t>{0b01010000, 0b01000101, 0x00}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{1, 8},
                      ov::element::u2,
                      ov::element::u3,
                      std::vector<uint8_t>{0b11011000, 0b10100100},
                      std::vector<uint8_t>{0b00100111, 0b00011010, 0x00}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u4,
                      ov::element::u3,
                      std::vector<uint8_t>{0x21, 0x01, 0x31, 0xff},
                      std::vector<uint8_t>{0b01100100, 0b01111111, 0b00000011}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{1, 8},
                      ov::element::u6,
                      ov::element::u3,
                      std::vector<uint8_t>{0x02, 0x13, 0x00, 0x41, 0x26, 0x00},
                      std::vector<uint8_t>{0b00100111, 0b00011010, 0b00001001}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u8,
                      ov::element::u3,
                      std::vector<uint8_t>{0, 2, 1, 3, 4, 1, 2, 2},
                      std::vector<uint8_t>{0b00100111, 0b00011010, 0b00001000}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u16,
                      ov::element::u3,
                      std::vector<uint16_t>{0, 2, 1, 3, 4, 1, 2, 2},
                      std::vector<uint8_t>{0b00100111, 0b00011010, 0b00001000}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u32,
                      ov::element::u3,
                      std::vector<uint32_t>{0, 2, 1, 3, 4, 1, 2, 2},
                      std::vector<uint8_t>{0b00100111, 0b00011010, 0b00001000}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u64,
                      ov::element::u3,
                      std::vector<uint64_t>{0, 2, 1, 3, 4, 1, 2, 2},
                      std::vector<uint8_t>{0b00100111, 0b00011010, 0b00001000}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::i8,
                      ov::element::u3,
                      std::vector<int8_t>{0, 2, 1, -3, 4, -1, 8, 7},
                      std::vector<uint8_t>{0b00100101, 0b00110011, 0b00011101}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::i16,
                      ov::element::u3,
                      std::vector<int16_t>{0, 2, 1, -3, 4, -1, 8, 7},
                      std::vector<uint8_t>{0b00100101, 0b00110011, 0b00011101}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::i32,
                      ov::element::u3,
                      std::vector<int32_t>{0, 2, 1, -3, 4, -1, 8, 7},
                      std::vector<uint8_t>{0b00100101, 0b00110011, 0b00011101}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::i64,
                      ov::element::u3,
                      std::vector<int64_t>{0, 2, 1, -3, 4, -1, 8, 7},
                      std::vector<uint8_t>{0b00100101, 0b00110011, 0b00011101}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::f8e4m3,
                      ov::element::u3,
                      std::vector<float8_e4m3>{0.0f, 2.1f, 1.7f, -3.1f, 4.0f, -1.0f, 8.0f, 7.2f},
                      std::vector<uint8_t>{0b00100101, 0b00110011, 0b00011101}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::f8e5m2,
                      ov::element::u3,
                      std::vector<float8_e5m2>{0.0f, 2.1f, 1.7f, -3.1f, 4.0f, -1.0f, 8.0f, 7.2f},
                      std::vector<uint8_t>{0b00100101, 0b00110011, 0b00011101}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::f16,
                      ov::element::u3,
                      std::vector<float16>{0.0f, 2.1f, 1.7f, -3.1f, 4.0f, -1.0f, 8.0f, 7.2f},
                      std::vector<uint8_t>{0b00100101, 0b00110011, 0b00011101}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::bf16,
                      ov::element::u3,
                      std::vector<bfloat16>{0.0f, 2.1f, 1.7f, -3.1f, 4.0f, -1.0f, 8.0f, 7.2f},
                      std::vector<uint8_t>{0b00100101, 0b00110011, 0b00011101}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::f32,
                      ov::element::u3,
                      std::vector<float>{0.0f, 2.1f, 1.7f, -3.1f, 4.0f, -1.0f, 8.0f, 7.2f},
                      std::vector<uint8_t>{0b00100101, 0b00110011, 0b00011101}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::f64,
                      ov::element::u3,
                      std::vector<double>{0.0, 2.1, 1.7, -3.1, 4.0, -1.0, 8.0, 7.2},
                      std::vector<uint8_t>{0b00100101, 0b00110011, 0b00011101}),
        // destination u6
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::boolean,
                      ov::element::u6,
                      std::vector<char>{1, 0, 1, 1, 0, 1, 0, 0},
                      std::vector<uint8_t>{0x10, 0x11, 0x00, 0x01, 0x00, 0x00}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u1,
                      ov::element::u6,
                      std::vector<uint8_t>{0b11001011},
                      std::vector<uint8_t>{0x11, 0x00, 0x00, 0x10, 0x11, 0x00}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{1, 8},
                      ov::element::u2,
                      ov::element::u6,
                      std::vector<uint8_t>{0b11011000, 0b00000100},
                      std::vector<uint8_t>{0x02, 0x13, 0x00, 0x01, 0x00, 0x00}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{1, 8},
                      ov::element::u3,
                      ov::element::u6,
                      std::vector<uint8_t>{0b00100111, 0b00011010, 0b00001001},
                      std::vector<uint8_t>{0x02, 0x13, 0x00, 0x41, 0x26, 0x00}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u4,
                      ov::element::u6,
                      std::vector<uint8_t>{0x21, 0x01, 0x31, 0xff},
                      std::vector<uint8_t>{0x12, 0x10, 0x00, 0x13, 0xff, 0x00}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u8,
                      ov::element::u6,
                      std::vector<uint8_t>{0, 2, 1, 3, 24, 1, 32, 52},
                      std::vector<uint8_t>{0x02, 0x13, 0x00, 0x81, 0x04, 0b01001011}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u16,
                      ov::element::u6,
                      std::vector<uint16_t>{0, 2, 1, 3, 24, 1, 32, 52},
                      std::vector<uint8_t>{0x02, 0x13, 0x00, 0x81, 0x04, 0b01001011}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u32,
                      ov::element::u6,
                      std::vector<uint32_t>{0, 2, 1, 3, 24, 1, 32, 52},
                      std::vector<uint8_t>{0x02, 0x13, 0x00, 0x81, 0x04, 0b01001011}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::u64,
                      ov::element::u6,
                      std::vector<uint64_t>{0, 2, 1, 3, 24, 1, 32, 52},
                      std::vector<uint8_t>{0x02, 0x13, 0x00, 0x81, 0x04, 0b01001011}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::i4,
                      ov::element::u6,
                      std::vector<uint8_t>{0x21, 0x01, 0x31, 0xff},
                      std::vector<uint8_t>{0x12, 0x10, 0x00, 0x13, 0xff, 0b00001111}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::i8,
                      ov::element::u6,
                      std::vector<int8_t>{0, 2, 1, -3, 24, -1, 32, 52},
                      std::vector<uint8_t>{0x02, 0x1d, 0b00000011, 0x8f, 0x04, 0b01111011}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::i16,
                      ov::element::u6,
                      std::vector<int16_t>{0, 2, 1, -3, 24, -1, 32, 52},
                      std::vector<uint8_t>{0x02, 0x1d, 0b00000011, 0x8f, 0x04, 0b01111011}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::i32,
                      ov::element::u6,
                      std::vector<int32_t>{0, 2, 1, -3, 24, -1, 32, 52},
                      std::vector<uint8_t>{0x02, 0x1d, 0b00000011, 0x8f, 0x04, 0b01111011}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::i64,
                      ov::element::u6,
                      std::vector<int64_t>{0, 2, 1, -3, 24, -1, 32, 52},
                      std::vector<uint8_t>{0x02, 0x1d, 0b00000011, 0x8f, 0x04, 0b01111011}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::f8e4m3,
                      ov::element::u6,
                      std::vector<float8_e4m3>{0.0f, 2.1f, 1.7f, -3.1f, 24.0f, -1.0f, 32.0f, 52.0f},
                      std::vector<uint8_t>{0x02, 0x1d, 0b00000011, 0x8f, 0x04, 0b01111011}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::f8e5m2,
                      ov::element::u6,
                      std::vector<float8_e5m2>{0.0f, 2.1f, 1.7f, -3.1f, 24.0f, -1.0f, 32.0f, 56.0f},
                      std::vector<uint8_t>{0x02, 0x1d, 0b00000011, 0x8f, 0x08, 0b01111011}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::f16,
                      ov::element::u6,
                      std::vector<float16>{0.0f, 2.1f, 1.7f, -3.1f, 24.0f, -1.0f, 32.0f, 52.0f},
                      std::vector<uint8_t>{0x02, 0x1d, 0b00000011, 0x8f, 0x04, 0b01111011}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::bf16,
                      ov::element::u6,
                      std::vector<bfloat16>{0.0f, 2.1f, 1.7f, -3.1f, 24.0f, -1.0f, 32.0f, 52.0f},
                      std::vector<uint8_t>{0x02, 0x1d, 0b00000011, 0x8f, 0x04, 0b01111011}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::f32,
                      ov::element::u6,
                      std::vector<float>{0.0f, 2.1f, 1.7f, -3.1f, 24.0f, -1.0f, 32.0f, 52.0f},
                      std::vector<uint8_t>{0x02, 0x1d, 0b00000011, 0x8f, 0x04, 0b01111011}),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{2, 4},
                      ov::element::f64,
                      ov::element::u6,
                      std::vector<double>{0.0, 2.1, 1.7, -3.1, 24.0, -1.0, 32.0, 52.0},
                      std::vector<uint8_t>{0x02, 0x1d, 0b00000011, 0x8f, 0x04, 0b01111011}),
        // destination f4e2m1
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{11},
                      ov::element::f16,
                      ov::element::f4e2m1,
                      std::vector<float16>{-0.9f, 0.0f, -6.5f, 1.2f, -0.6f, 2.0f, -1.5f, 1.5f, -0.1f, 6.0f, 2.8f},
                      f4e2m1_values),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{11},
                      ov::element::bf16,
                      ov::element::f4e2m1,
                      std::vector<bfloat16>{-1.2f, 0.2f, -6.5f, 1.2f, -0.6f, 2.49f, -1.4f, 1.5f, -0.1f, 6.0f, 2.8f},
                      f4e2m1_values),
        ConvertParams(ConversionTypes::CONVERT_LIKE,
                      ov::PartialShape{11},
                      ov::element::f32,
                      ov::element::f4e2m1,
                      std::vector<float>{-1.2f, 0.2f, -6.5f, 1.2f, -0.6f, 2.49f, -1.5f, 1.6f, -0.1f, 6.0f, 2.8f},
                      f4e2m1_values),
        // destination f8e8m0
        ConvertParams(
            ConversionTypes::CONVERT_LIKE,
            ov::PartialShape{11},
            ov::element::f16,
            ov::element::f8e8m0,
            std::vector<float16>{-1.2f, 0.05f, 0.1f, 0.2f, 0.3f, 0.4f, 0.7f, 1.2f, 2.49f, 1.6f, 6.0f, 2.8f},
            std::vector<float8_e8m0>{e8m0_min, 0.0625, 0.125, 0.25f, 0.25f, 0.5f, 0.5f, 1.0f, 2.0f, 2.0f, 8.0f, 2.0f}),
        ConvertParams(
            ConversionTypes::CONVERT_LIKE,
            ov::PartialShape{12},
            ov::element::bf16,
            ov::element::f8e8m0,
            std::vector<bfloat16>{-1.2f, 0.05f, 0.1f, 0.2f, 0.3f, 0.4f, 0.7f, 1.2f, 2.49f, 1.6f, 6.0f, 2.8f},
            std::vector<float8_e8m0>{e8m0_min, 0.0625, 0.125, 0.25f, 0.25f, 0.5f, 0.5f, 1.0f, 2.0f, 2.0f, 8.0f, 2.0f}),
        ConvertParams(
            ConversionTypes::CONVERT_LIKE,
            ov::PartialShape{12},
            ov::element::f32,
            ov::element::f8e8m0,
            std::vector<float>{-1.2f, 0.05f, 0.1f, 0.2f, 0.3f, 0.4f, 0.7f, 1.2f, 2.49f, 1.6f, 6.0f, 2.8f},
            std::vector<float8_e8m0>{e8m0_min, 0.0625, 0.125, 0.25f, 0.25f, 0.5f, 0.5f, 1.0f, 2.0f, 2.0f, 8.0f, 2.0f})),
    ReferenceConversionLayerTest::getTestCaseName);
}  // namespace
}  // namespace ConversionOpsRefTestDefinitions
}  // namespace reference_tests
